package com.opc.Service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.opc.Common.MessageConstant;
import com.opc.Mapper.CarMapper;
import com.opc.Mapper.SampleScrewMapper;
import com.opc.Pojo.Car;
import com.opc.Pojo.SampleScrew;
import com.opc.Service.CarService;
import com.opc.properties.CarTypeProperties;
import com.opc.websocket.WebSocketServer;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.usermodel.Color;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.xddf.usermodel.chart.*;
import org.apache.poi.xssf.usermodel.*;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartUtils;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.axis.NumberAxis;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;
import org.openxmlformats.schemas.drawingml.x2006.chart.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.awt.*;
import java.awt.geom.Ellipse2D;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.YearMonth;
import java.time.ZoneId;
import java.util.*;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

import org.apache.poi.hssf.usermodel.HSSFPatriarch;

@Repository
@Service
@Slf4j
public class CarServiceImpl extends ServiceImpl<CarMapper, Car> implements CarService {

    @Value("${historyData.samplePath}")//必须是org.springframework.beans.factory.annotation提供的Value
    private String basePath;
    @Autowired
    private CarTypeProperties carTypeProperties;
    @Autowired
    private WebSocketServer webSocketServer;
    @Autowired
    private SampleScrewMapper sampleScrewMapper;

//    @Override
//    public byte[] exportToExcel() {
//        LocalDate today = LocalDate.now();
//        YearMonth currentYearMonth = YearMonth.from(today);
//        YearMonth previousYearMonth = currentYearMonth.minusMonths(1);
//        log.info("前一个月是："+previousYearMonth);
//        System.out.println("前一个月是："+previousYearMonth);
//        String month = previousYearMonth.toString();
//        // 处理凯美瑞车型
//        Map result1 = processCarType(carTypeProperties.getCamry(), month);
//        if(result1 == null){
//            return null;
//        }
//
//        // 处理雷凌车型的数据
//        Map result2 = processCarType(carTypeProperties.getLevin(), month);
//        if(result2 == null){
//            return null;
//        }
//
//        LambdaQueryWrapper<SampleScrew> queryWrapper = new LambdaQueryWrapper<>();
//        YearMonth previouspreviousYearMonth = previousYearMonth.minusMonths(1);
//        System.out.println("previouspreviousYearMonth是"+previouspreviousYearMonth);
//        queryWrapper.le(SampleScrew::getScrewCreateTime, previouspreviousYearMonth);
//
//        HSSFWorkbook excel1 = null;
//        System.out.println("result1.get(excel)是"+result1.get("excel"));
//        if (result1 != null) {
//            excel1 = (HSSFWorkbook) result1.get("excel");
//        }
//
//        HSSFWorkbook excel2 = null;
//        if (result2 != null) {
//            excel2 = (HSSFWorkbook) result2.get("excel");
//        }
//        System.out.println("result2.get(excel)是"+result2.get("excel"));
//        if (result2 != null && result1 != null &&
//                result1.get("excel") != null &&
//                result2.get("excel") != null) {
//            //清空上上个月的整个表
////            sampleScrewMapper.delete(queryWrapper);
//            log.info("清空了所有样本");
//        }
//
//        // 创建一个ByteArrayOutputStream来存储ZIP文件
//        ByteArrayOutputStream zipOutputStream = new ByteArrayOutputStream();
//        ZipOutputStream zos = new ZipOutputStream(zipOutputStream);
//
//        try {
//            // 将第一个Excel文件添加到ZIP
//            if (excel1 != null) {
//                ZipEntry zipEntry1 = new ZipEntry(MessageConstant.camryFileName);
//                zos.putNextEntry(zipEntry1);
//                excel1.write(zos);
//                zos.closeEntry();
//                excel1.close();
//            }
//
//            // 将第二个Excel文件添加到ZIP
//            if (excel2 != null) {
//                ZipEntry zipEntry2 = new ZipEntry(MessageConstant.levinFileName);
//                zos.putNextEntry(zipEntry2);
//                excel2.write(zos);
//                zos.closeEntry();
//                excel2.close();
//            }
//        } catch (IOException e) {
//            e.printStackTrace();
//        } finally {
//            try {
//                zos.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }
//        }
//
//        // 返回ZIP文件的字节数组
//        return zipOutputStream.toByteArray();
//    }

    @Override
    @Transactional
    public Map exportToExcel() {
        LocalDate today = LocalDate.now();
        YearMonth currentYearMonth = YearMonth.from(today);
        YearMonth previousYearMonth = currentYearMonth.minusMonths(1);
        log.info("前一个月是："+previousYearMonth);
//        System.out.println("前一个月是："+previousYearMonth);
        String month = previousYearMonth.toString();
        // 处理凯美瑞车型NewProcessCarType   NewLineChartProcessCarType
        Map result1 = NewProcessCarType(carTypeProperties.getCamry(), month);

        // 处理雷凌车型的数据
        Map result2 = processCarType(carTypeProperties.getLevin(), month);

        LambdaQueryWrapper<SampleScrew> queryWrapper = new LambdaQueryWrapper<>();
//        YearMonth previouspreviousYearMonth = previousYearMonth.minusMonths(1);
//        System.out.println("previouspreviousYearMonth是"+previouspreviousYearMonth);
        System.out.println("previousYearMonth是"+month);
//        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM");
//// 将字符串转换为LocalDate
//        LocalDate date = LocalDate.parse(month, formatter);
        // 获取该月第一天的 LocalDate
        LocalDate firstDayOfMonth = previousYearMonth.atDay(1);
        System.out.println("firstDayOfMonth是"+firstDayOfMonth);
        queryWrapper.le(SampleScrew::getScrewCreateTime, firstDayOfMonth);
        HSSFWorkbook excel1 = null;
        if (result1 != null) {
            excel1 = (HSSFWorkbook) result1.get("excel");
        }
        HSSFWorkbook excel2 = null;
        if (result2 != null) {
            excel2 = (HSSFWorkbook) result2.get("excel");
        }

        if (result2 != null && result1 != null &&
                result1.get("excel") != null &&
                result2.get("excel") != null) {
            //清空上上个月的整个表
            System.out.println("清空");
            sampleScrewMapper.delete(queryWrapper);
            log.info("清空了前前个月所有样本");
        }

        HttpHeaders header1 = new HttpHeaders();
        header1.setContentType(MediaType.parseMediaType("application/vnd.ms-excel"));
        header1.setContentDispositionFormData("attachment", MessageConstant.camryFileName);
//        header1.setContentType(MediaType.parseMediaType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"));
//        header1.setContentDispositionFormData("attachment", MessageConstant.camryFileName);
        ByteArrayOutputStream outputStream1 = new ByteArrayOutputStream();

        HttpHeaders header2 = new HttpHeaders();
        header2.setContentType(MediaType.parseMediaType("application/vnd.ms-excel"));
        header2.setContentDispositionFormData("attachment", MessageConstant.levinFileName);
//        header2.setContentType(MediaType.parseMediaType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"));
//        header2.setContentDispositionFormData("attachment", MessageConstant.levinFileName);
        ByteArrayOutputStream outputStream2 = new ByteArrayOutputStream();
        try {
            if(excel1 != null){
                excel1.write(outputStream1);
            }
            if(excel2 != null){
                excel2.write(outputStream2);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            if(excel1 != null) {
                excel1.close();
            }
            if(excel2 != null) {
                excel2.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
//        return outputStream.toByteArray();
        // 返回ResponseEntity
        Map map = new HashMap<>();
        map.put("excel1", outputStream1.toByteArray());
        map.put("excel1Name", result1.get("excel1Name"));
        map.put("excel2", outputStream2.toByteArray());
        map.put("excel2Name", result2.get("excel2Name"));
        return map;
    }

    private static String convertLocalDateTimeToString(Date Time) {
        LocalDateTime localDateTime = Time.toInstant()
                .atZone(ZoneId.systemDefault())
                .toLocalDateTime();
        String formattedTime = String.format("%04d:%02d:%02d:%02d:%02d:%02d",
                localDateTime.getYear(),
                localDateTime.getMonthValue(),
                localDateTime.getDayOfMonth(),
                localDateTime.getHour(),
                localDateTime.getMinute(),
                localDateTime.getSecond());
//        log.info("formattedTime是"+formattedTime);
        // 使用 replace() 方法替换第一个 ':' 为 '-'
        // 使用正则表达式替换前两个 ':' 为 '-'
        // 拆分字符串
        String[] parts = formattedTime.toString().split(":");
        // 重新组装字符串
        String newFormattedTime = String.join("-", parts[0], parts[1]) + "-" + parts[2] + " " + parts[3] + ":" + parts[4] + ":" + parts[5];
//        log.info("timeFormatter是"+newFormattedTime);
        return newFormattedTime;
    }

//    private void createDirectoryIfNotExists(String directoryPath) {
//        Path path = Paths.get(directoryPath);
//        // 检查目录是否存在
//        if (!Files.exists(path)) {
//            try {
//                // 创建目录（包括必要的父目录）
//                Files.createDirectories(path);
//                log.info("目录已创建: " + directoryPath);
//            } catch (IOException e) {
//                System.err.println("无法创建目录: " + e.getMessage());
//                if(e.getMessage().contains("Unable to determine if root directory exists")){
//                    log.info("创建文件夹失败，没有这个盘");
//                    Map map = new HashMap<>();
//                    int colonIndex = basePath.indexOf(':');
//                    if (colonIndex != -1) {
//                        String result = basePath.substring(0, colonIndex);
//                        map.put("message", "创建备份目录失败，找不到磁盘"+result);
//                    }
//                    String json = JSON.toJSONString(map);
//                    webSocketServer.sendToAllClient(json);
//                }
//            }
//        } else {
//            log.info("目录已存在: " + directoryPath);
//        }
//    }

//    private Map<String, Object> NewLineChartProcessCarType(String carType, String month) {
//        // 构建查询条件
//        // 这里假设 LambdaQueryWrapper 类是你自定义的查询条件构建类
//        LambdaQueryWrapper<SampleScrew> querySampleScrewWrapper = new LambdaQueryWrapper<>();
//        querySampleScrewWrapper.like(SampleScrew::getScrewCreateTime, month);
//        querySampleScrewWrapper.eq(SampleScrew::getCarType, carType);
//
//        List<SampleScrew> sampleScrews = sampleScrewMapper.selectList(querySampleScrewWrapper);
//
//        if (sampleScrews.isEmpty()) {
//            System.out.println("没有找到前个月的" + carType + "车型");
//            return null;
//        }
//
//        // 加载模板文件
//        InputStream in = null;
//        if (carType.equals(carTypeProperties.getCamry())) {
//            in = this.getClass().getClassLoader()
//                    .getResourceAsStream("template/" + MessageConstant.camryFileName);
//        } else if (carType.equals(carTypeProperties.getLevin())) {
//            in = this.getClass().getClassLoader()
//                    .getResourceAsStream("template/" + MessageConstant.levinFileName);
//        } else {
//            System.out.println("未知车型");
//            return null;
//        }
//
//        // 基于模板文件创建 Excel 文件
//        XSSFWorkbook excel = null;
//        try {
//            POIFSFileSystem fs = new POIFSFileSystem();
//            if (in != null) {
//                fs = new POIFSFileSystem(in);
//            }
//            excel = new XSSFWorkbook(String.valueOf(fs));
//        } catch (IOException e) {
//            throw new RuntimeException(e);
//        }
//
//        // 获取各个工作表
//        XSSFSheet YQSheet = excel.getSheet("右前门扭力");
//        XSSFSheet ZQSheet = excel.getSheet("左前门扭力");
//        XSSFSheet YHSheet = excel.getSheet("右后门扭力 (2)");
//        XSSFSheet ZHSheet = excel.getSheet("左后门扭力");
//        XSSFSheet CGSheet = excel.getSheet("发动机盖");
//
//        if (carType.equals(carTypeProperties.getCamry())) {
//            // 处理左前后门数据
//            int[][] filledCounts = new int[32][21];
//            List<Double>[] leftFrontDoorSamples = new ArrayList[4];
//            for (int i = 0; i < 4; i++) {
//                leftFrontDoorSamples[i] = new ArrayList<>();
//            }
//            int sampleIndex = 0;
//            for (SampleScrew sampleScrew : sampleScrews) {
//                String dayStr = sampleScrew.getScrewCreateTime().toString().split("-")[2];
//                int day = Integer.parseInt(dayStr);
//                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//                if (screwTypeId >= 5) {
//                    continue;
//                }
//
//                if (filledCounts[day][screwTypeId] < 4) {
//                    leftFrontDoorSamples[sampleIndex].add(sampleScrew.getTorque());
//                    filledCounts[day][screwTypeId]++;
//                    if (filledCounts[day][screwTypeId] == 4) {
//                        sampleIndex++;
//                    }
//                }
//            }
//            // 获取日期列表String
//            List<Date> dateList = sampleScrews.stream()
//                    .map(SampleScrew::getScrewCreateTime)
//                    .distinct()
//                    .collect(Collectors.toList());
//            drawLineChart(ZQSheet, leftFrontDoorSamples, "左前门抽样数据变化趋势图", 1, 3, dateList);
//
//            // 处理左后门数据
//            int[][] filledCounts2 = new int[32][21];
//            List<Double>[] leftBackDoorSamples = new ArrayList[4];
//            for (int i = 0; i < 4; i++) {
//                leftBackDoorSamples[i] = new ArrayList<>();
//            }
//            sampleIndex = 0;
//            for (SampleScrew sampleScrew : sampleScrews) {
//                String dayStr = sampleScrew.getScrewCreateTime().toString().split("-")[2];
//                int day = Integer.parseInt(dayStr);
//                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//                if (screwTypeId <= 4 || screwTypeId >= 9) {
//                    continue;
//                }
//
//                if (filledCounts2[day][screwTypeId] < 4) {
//                    leftBackDoorSamples[sampleIndex].add(sampleScrew.getTorque());
//                    filledCounts2[day][screwTypeId]++;
//                    if (filledCounts2[day][screwTypeId] == 4) {
//                        sampleIndex++;
//                    }
//                }
//            }
//            drawLineChart(ZHSheet, leftBackDoorSamples, "左后门抽样数据变化趋势图", 1, 3, dateList);
//
//            // 处理右前门数据
//            int[][] filledCounts3 = new int[32][21];
//            List<Double>[] rightFrontDoorSamples = new ArrayList[4];
//            for (int i = 0; i < 4; i++) {
//                rightFrontDoorSamples[i] = new ArrayList<>();
//            }
//            sampleIndex = 0;
//            for (SampleScrew sampleScrew : sampleScrews) {
//                String dayStr = sampleScrew.getScrewCreateTime().toString().split("-")[2];
//                int day = Integer.parseInt(dayStr);
//                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//                if (screwTypeId <= 8 || screwTypeId >= 13) {
//                    continue;
//                }
//
//                if (filledCounts3[day][screwTypeId] < 4) {
//                    rightFrontDoorSamples[sampleIndex].add(sampleScrew.getTorque());
//                    filledCounts3[day][screwTypeId]++;
//                    if (filledCounts3[day][screwTypeId] == 4) {
//                        sampleIndex++;
//                    }
//                }
//            }
//
//            drawLineChart(YQSheet, rightFrontDoorSamples, "右前门抽样数据变化趋势图", 1, 3, dateList);
//
//            // 处理右后门数据
//            int[][] filledCounts4 = new int[32][21];
//            List<Double>[] rightBackDoorSamples = new ArrayList[4];
//            for (int i = 0; i < 4; i++) {
//                rightBackDoorSamples[i] = new ArrayList<>();
//            }
//            sampleIndex = 0;
//            for (SampleScrew sampleScrew : sampleScrews) {
//                String dayStr = sampleScrew.getScrewCreateTime().toString().split("-")[2];
//                int day = Integer.parseInt(dayStr);
//                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//                if (screwTypeId <= 12 || screwTypeId >= 17) {
//                    continue;
//                }
//
//                if (filledCounts4[day][screwTypeId] < 4) {
//                    rightBackDoorSamples[sampleIndex].add(sampleScrew.getTorque());
//                    filledCounts4[day][screwTypeId]++;
//                    if (filledCounts4[day][screwTypeId] == 4) {
//                        sampleIndex++;
//                    }
//                }
//            }
//            drawLineChart(YHSheet, rightBackDoorSamples, "右后门抽样数据变化趋势图", 1, 3, dateList);
//
//            // 处理车盖数据
//            int[][] filledCounts5 = new int[32][21];
//            List<Double>[] hoodSamples = new ArrayList[4];
//            for (int i = 0; i < 4; i++) {
//                hoodSamples[i] = new ArrayList<>();
//            }
//            sampleIndex = 0;
//            for (SampleScrew sampleScrew : sampleScrews) {
//                String dayStr = sampleScrew.getScrewCreateTime().toString().split("-")[2];
//                int day = Integer.parseInt(dayStr);
//                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//                if (screwTypeId <= 16 || screwTypeId >= 21) {
//                    continue;
//                }
//
//                if (filledCounts5[day][screwTypeId] < 2) {
//                    hoodSamples[sampleIndex].add(sampleScrew.getTorque());
//                    filledCounts5[day][screwTypeId]++;
//                    if (filledCounts5[day][screwTypeId] == 2) {
//                        sampleIndex++;
//                    }
//                }
//            }
//            drawLineChart(CGSheet, hoodSamples, "发动机盖抽样数据变化趋势图", 1, 3, dateList);
//        } else if (carType.equals(carTypeProperties.getLevin())) {
//            // 与凯美瑞车型类似的处理逻辑，此处省略具体实现
//        } else {
//            System.out.println("未知车型");
//            return null;
//        }
//
//        String fileName = null;
//        if (carType.equals(carTypeProperties.getCamry())) {
//            fileName = "(" + month + ")" + MessageConstant.camryFileName;
//        } else if (carType.equals(carTypeProperties.getLevin())) {
//            fileName = "(" + month + ")" + MessageConstant.levinFileName;
//        }
//
//        Map<String, Object> map = new HashMap<>();
//        map.put("fileName", fileName);
//        map.put("excel", excel);
//        return map;
//    }
//
//    private void drawLineChart(XSSFSheet sheet, List<Double>[] samples, String chartTitle,
//                               int startRow, int startCol, List<Date> dateList) {
//        XSSFDrawing drawing = sheet.createDrawingPatriarch();
//        XSSFClientAnchor anchor = new XSSFClientAnchor(0, 0, 0, 0, (short) startCol, startRow, (short) (startCol + 10), startRow + 15);
//        XSSFChart chart = drawing.createChart(anchor);
//
//        CTChart ctChart = chart.getCTChart();
//        // 设置标题
//        chart.setTitleText(chartTitle);
//        ctChart.getTitle().addNewOverlay().setVal(false);
//
//        // 设置图例
//        CTLegend ctLegend = ctChart.addNewLegend();
//        ctLegend.addNewLegendPos().setVal(STLegendPos.B);
//        ctLegend.addNewOverlay().setVal(false);
//
//        // 获取图表的工作区域
//        CTPlotArea ctPlotArea = ctChart.getPlotArea();
//        // 添加一个新的线型图表
//        CTLineChart ctLineChart = ctPlotArea.addNewLineChart();
//
//        // 配置坐标轴
//        XDDFChartAxis bottomAxis = chart.createCategoryAxis(AxisPosition.BOTTOM);
//        bottomAxis.setTitle("日期");
//        XDDFValueAxis leftAxis = chart.createValueAxis(AxisPosition.LEFT);
//        leftAxis.setTitle("扭力值");
//        leftAxis.setCrosses(AxisCrosses.AUTO_ZERO);
//
//        // 关联数据区域
//        String[] xDataArray = dateList.toArray(new String[0]);
//        XDDFDataSource<String> xData = XDDFDataSourcesFactory.fromArray(xDataArray);
//
//        XDDFNumericalDataSource[][] yDataArray = new XDDFNumericalDataSource[1][samples.length];
//        for (int i = 0; i < samples.length; i++) {
//            Double[] sampleArray = samples[i].toArray(new Double[0]);
//            yDataArray[0][i] = XDDFDataSourcesFactory.fromArray(sampleArray);
//        }
//
//        XDDFLineChartData dataSeries = (XDDFLineChartData) chart.createData(ChartTypes.LINE, bottomAxis, leftAxis);
//        for (int i = 0; i < samples.length; i++) {
//            XDDFLineChartData.Series series = (XDDFLineChartData.Series) dataSeries.addSeries(xData, yDataArray[0][i]);
//            series.setTitle("第" + (i + 1) + "次抽样", null);
//            series.setSmooth(true);
//            series.setMarkerStyle(MarkerStyle.CIRCLE);
//        }
//
//        // 绘制图表
//        chart.plot(dataSeries);
//    }
//

    //-----------------------------


//    private Map NewLineChartProcessCarType(String carType, String month) {
//        LambdaQueryWrapper<SampleScrew> querySampleScrewWrapper = new LambdaQueryWrapper<>();
//        querySampleScrewWrapper.like(SampleScrew::getScrewCreateTime, month);
//        querySampleScrewWrapper.eq(SampleScrew::getCarType, carType);
//        List<SampleScrew> sampleScrews = sampleScrewMapper.selectList(querySampleScrewWrapper);
//
//        if (sampleScrews.isEmpty()) {
//            System.out.println("没有找到前个月的" + carType + "车型");
////            return null;
//        }
//
//        //如果数据库里有凯美瑞的车型样本，就先把所有凯美瑞的车型查出来，然后每天每30台车取一粒螺丝扭力检测数据
//        InputStream in = null;
//        if (carType.equals(carTypeProperties.getCamry())) {
//            in = this.getClass().getClassLoader()
//                    .getResourceAsStream("template/" + MessageConstant.camryFileName);
//        } else if (carType.equals(carTypeProperties.getLevin())) {
//            in = this.getClass().getClassLoader()
//                    .getResourceAsStream("template/" + MessageConstant.levinFileName);
//        } else {
//            log.info("未知车型");
//            return null;
//        }
//        //基于模板文件创建Excel文件
//        //旧格式
//        XSSFWorkbook excel = null;
//        try {
//            POIFSFileSystem fs = null;
//            if (in != null) {
//                fs = new POIFSFileSystem(in);
//            }
////            excel = new HSSFWorkbook(fs);
//            excel = new XSSFWorkbook(String.valueOf(fs));
//        } catch (IOException e) {
//            throw new RuntimeException(e);
//        }
//        //HSSFSheet
//        XSSFSheet YQSheet = excel.getSheet("右前门扭力");
//        XSSFSheet ZQSheet = excel.getSheet("左前门扭力");
//        XSSFSheet YHSheet = excel.getSheet("右后门扭力 (2)");
//        XSSFSheet ZHSheet = excel.getSheet("左后门扭力");
//        XSSFSheet CGSheet = excel.getSheet("发动机盖");
//
//        if (carType.equals(carTypeProperties.getCamry())) {
//            // 处理左前后门数据
//            int[][] filledCounts = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
//            List<Double>[] leftFrontDoorSamples = new ArrayList[4];
//            for (int i = 0; i < 4; i++) {
//                leftFrontDoorSamples[i] = new ArrayList<>();
//            }
//            int sampleIndex = 0;
//            for (SampleScrew sampleScrew : sampleScrews) {
//                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//                int spaceIndex = createTime.indexOf(' ');
//                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
//                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//                int day = Integer.parseInt(dayStr);
//                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//                if (screwTypeId >= 5) {
//                    continue;
//                }
//
//                if (filledCounts[day][screwTypeId] < 4) {
//                    leftFrontDoorSamples[sampleIndex].add(sampleScrew.getTorque());
//                    // 计算行号和列号并填充数据，此处省略原填充单元格逻辑
//                    filledCounts[day][screwTypeId]++;
//                    if (filledCounts[day][screwTypeId] == 4) {
//                        sampleIndex++;
//                    }
//                }
//            }
//            // 在左前门数据上方绘制折线图
//            drawLineChart(ZQSheet, leftFrontDoorSamples, "左前门抽样数据变化趋势图", 1, 3);
//
//            // 处理左后门数据
//            int[][] filledCounts2 = new int[32][21];
//            List<Double>[] leftBackDoorSamples = new ArrayList[4];
//            for (int i = 0; i < 4; i++) {
//                leftBackDoorSamples[i] = new ArrayList<>();
//            }
//            sampleIndex = 0;
//            for (SampleScrew sampleScrew : sampleScrews) {
//                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//                int spaceIndex = createTime.indexOf(' ');
//                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
//                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//                int day = Integer.parseInt(dayStr);
//                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//                if (screwTypeId <= 4 || screwTypeId >= 9) {
//                    continue;
//                }
//
//                if (filledCounts2[day][screwTypeId] < 4) {
//                    leftBackDoorSamples[sampleIndex].add(sampleScrew.getTorque());
//                    // 计算行号和列号并填充数据，此处省略原填充单元格逻辑
//                    filledCounts2[day][screwTypeId]++;
//                    if (filledCounts2[day][screwTypeId] == 4) {
//                        sampleIndex++;
//                    }
//                }
//            }
//            // 在左后门数据上方绘制折线图
//            drawLineChart(ZHSheet, leftBackDoorSamples, "左后门抽样数据变化趋势图", 1, 3);
//
//            // 处理右前门数据
//            int[][] filledCounts3 = new int[32][21];
//            List<Double>[] rightFrontDoorSamples = new ArrayList[4];
//            for (int i = 0; i < 4; i++) {
//                rightFrontDoorSamples[i] = new ArrayList<>();
//            }
//            sampleIndex = 0;
//            for (SampleScrew sampleScrew : sampleScrews) {
//                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//                int spaceIndex = createTime.indexOf(' ');
//                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
//                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//                int day = Integer.parseInt(dayStr);
//                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//                if (screwTypeId <= 8 || screwTypeId >= 13) {
//                    continue;
//                }
//
//                if (filledCounts3[day][screwTypeId] < 4) {
//                    rightFrontDoorSamples[sampleIndex].add(sampleScrew.getTorque());
//                    // 计算行号和列号并填充数据，此处省略原填充单元格逻辑
//                    filledCounts3[day][screwTypeId]++;
//                    if (filledCounts3[day][screwTypeId] == 4) {
//                        sampleIndex++;
//                    }
//                }
//            }
//            // 在右前门数据上方绘制折线图
//            drawLineChart(YQSheet, rightFrontDoorSamples, "右前门抽样数据变化趋势图", 1, 3);
//
//            // 处理右后门数据
//            int[][] filledCounts4 = new int[32][21];
//            List<Double>[] rightBackDoorSamples = new ArrayList[4];
//            for (int i = 0; i < 4; i++) {
//                rightBackDoorSamples[i] = new ArrayList<>();
//            }
//            sampleIndex = 0;
//            for (SampleScrew sampleScrew : sampleScrews) {
//                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//                int spaceIndex = createTime.indexOf(' ');
//                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
//                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//                int day = Integer.parseInt(dayStr);
//                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//                if (screwTypeId <= 12 || screwTypeId >= 17) {
//                    continue;
//                }
//
//                if (filledCounts4[day][screwTypeId] < 4) {
//                    rightBackDoorSamples[sampleIndex].add(sampleScrew.getTorque());
//                    // 计算行号和列号并填充数据，此处省略原填充单元格逻辑
//                    filledCounts4[day][screwTypeId]++;
//                    if (filledCounts4[day][screwTypeId] == 4) {
//                        sampleIndex++;
//                    }
//                }
//            }
//            // 在右后门数据上方绘制折线图
//            drawLineChart(YHSheet, rightBackDoorSamples, "右后门抽样数据变化趋势图", 1, 3);
//
//            // 处理车盖数据
//            int[][] filledCounts5 = new int[32][21];
//            List<Double>[] hoodSamples = new ArrayList[4];
//            for (int i = 0; i < 4; i++) {
//                hoodSamples[i] = new ArrayList<>();
//            }
//            sampleIndex = 0;
//            for (SampleScrew sampleScrew : sampleScrews) {
//                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//                int spaceIndex = createTime.indexOf(' ');
//                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
//                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//                int day = Integer.parseInt(dayStr);
//                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//                if (screwTypeId <= 16 || screwTypeId >= 21) {
//                    continue;
//                }
//
//                if (filledCounts5[day][screwTypeId] < 2) {
//                    hoodSamples[sampleIndex].add(sampleScrew.getTorque());
//                    // 计算行号和列号并填充数据，此处省略原填充单元格逻辑
//                    filledCounts5[day][screwTypeId]++;
//                    if (filledCounts5[day][screwTypeId] == 2) {
//                        sampleIndex++;
//                    }
//                }
//            }
//            // 在车盖数据上方绘制折线图
//            drawLineChart(CGSheet, hoodSamples, "发动机盖抽样数据变化趋势图", 1, 3);
//        } else if (carType.equals(carTypeProperties.getLevin())) {
//            // 与凯美瑞车型类似的处理逻辑，此处省略具体实现
//        } else {
//            log.info("未知车型");
//            return null;
//        }
//
//        String fileName = null;
//        if (carType.equals(carTypeProperties.getCamry())) {
//            fileName = "(" + month + ")" + MessageConstant.camryFileName;
//        } else if (carType.equals(carTypeProperties.getLevin())) {
//            fileName = "(" + month + ")" + MessageConstant.levinFileName;
//        }
//
//        Map map = new HashMap();
//        map.put("fileName", fileName);
//        map.put("excel", excel);
//        return map;
//    }
//
//    private void drawLineChart(XSSFSheet sheet, List<Double>[] samples, String chartTitle, int startRow, int startCol) {
//        XSSFDrawing drawing = sheet.createDrawingPatriarch();
//        XSSFClientAnchor anchor = new XSSFClientAnchor(0, 0, 0, 0, (short) startCol, startRow, (short) (startCol + 10), startRow + 15);
//        XSSFChart chart = drawing.createChart(anchor);
//
//        CTChart ctChart = chart.getCTChart();
//        // 设置标题
//        chart.setTitleText(chartTitle);
//        ctChart.getTitle().addNewOverlay().setVal(false); // 图表标题不覆盖图表内容
//
//        // 设置图例
//        CTLegend ctLegend = ctChart.addNewLegend();
//        ctLegend.addNewLegendPos().setVal(STLegendPos.B); // 图例位置为下边
//        ctLegend.addNewOverlay().setVal(false);
//
//        // 获取图表的工作区域
//        CTPlotArea ctPlotArea = ctChart.getPlotArea();
//        // 添加一个新的线型图表
//        CTLineChart ctLineChart = ctPlotArea.addNewLineChart();
//
//        // 配置坐标轴
//        XDDFChartAxis bottomAxis = chart.createCategoryAxis(AxisPosition.BOTTOM);
//        bottomAxis.setTitle("日期");
//        XDDFValueAxis leftAxis = chart.createValueAxis(AxisPosition.LEFT);
//        leftAxis.setTitle("扭力值");
//        leftAxis.setCrosses(AxisCrosses.AUTO_ZERO);
//
//        // 关联数据区域
//        // 假设 x 轴数据是从 1 到当月最大天数（这里简单假设 31 天，实际应根据数据调整）
//        int numDays = 31;
//        Double[] xDataArray = new Double[numDays];
//        for (int i = 0; i < numDays; i++) {
//            xDataArray[i] = (double) (i + 1);
//        }
//        XDDFDataSource<Double> xData = XDDFDataSourcesFactory.fromArray(xDataArray);
//
//        XDDFNumericalDataSource<Double>[][] yDataArray = new XDDFNumericalDataSource[1][samples.length];
//        for (int i = 0; i < samples.length; i++) {
//            Double[] sampleArray = samples[i].toArray(new Double[0]);
//            yDataArray[0][i] = XDDFDataSourcesFactory.fromArray(sampleArray);
//        }
//
//        XDDFLineChartData dataSeries = (XDDFLineChartData) chart.createData(ChartTypes.LINE, bottomAxis, leftAxis);
//        for (int i = 0; i < samples.length; i++) {
//            XDDFLineChartData.Series series = (XDDFLineChartData.Series) dataSeries.addSeries(xData, yDataArray[0][i]);
//            series.setTitle("第" + (i + 1) + "次抽样", null);
//            series.setSmooth(true);
//            series.setMarkerStyle(MarkerStyle.CIRCLE);
//        }
//
//        // 绘制图表
//        chart.plot(dataSeries);
//    }

    /**
     * 生成螺丝抽样趋势图表（Lambda版本）
     */
//    public void generateScrewSamplingCharts(String carType, String month) {
//        log.info("开始生成螺丝抽样趋势图表 - 车型: {}, 月份: {}", carType, month);
//
//        // 查询数据（复用你现有的查询逻辑）
//        LambdaQueryWrapper<SampleScrew> queryWrapper = new LambdaQueryWrapper<>();
//        queryWrapper.like(SampleScrew::getScrewCreateTime, month);
//        queryWrapper.eq(SampleScrew::getCarType, carType);
//        List<SampleScrew> sampleScrews = sampleScrewMapper.selectList(queryWrapper);
//
//        if (sampleScrews.isEmpty()) {
//            log.warn("未找到 {} 车型在 {} 的螺丝抽样数据", carType, month);
//            return;
//        }
//
//        // 使用Lambda表达式处理数据并生成图表
//        processScrewDataAndGenerateCharts(sampleScrews, carType, month);
//    }

    /**
     * 处理螺丝数据并生成图表（Lambda版本）
     */
//    private void processScrewDataAndGenerateCharts(List<SampleScrew> sampleScrews,
//                                                   String carType, String month) {
//        // 解析年月
////        int year = Integer.parseInt(month.substring(0, 4));
//        int monthValue = Integer.parseInt(month.substring(5, 7));
//        System.out.println("monthValue 是：" + monthValue);
//        // 按螺丝类型分组处理
//        sampleScrews.stream()
//                .collect(Collectors.groupingBy(SampleScrew::getScrewTypeId))
//                .forEach((screwTypeId, screws) ->
//                        generateChartForScrewType(screws, screwTypeId, monthValue, carType)//year,
//                        );
//
//        log.info("✅ {} 车型 {} 月份螺丝抽样图表生成完成", carType, month);
//    }

    /**
     * 为特定螺丝类型生成图表（Lambda版本）
     */
//    private void generateChartForScrewType(List<SampleScrew> screws, Long screwTypeId,
//                                           int month, String carType) {//int year,
//        // 按日期和抽样顺序分组数据
//        Map<Integer, Map<Integer, List<SampleScrew>>> dailyData = screws.stream()
//                .collect(Collectors.groupingBy(
//                        screw -> extractDayFromDateTime(screw.getScrewCreateTime()),
//                        Collectors.groupingBy(this::calculateSampleOrder)
//                ));
//
//        // 创建数据集
//        XYSeriesCollection dataset = createDataset(dailyData);
//
//        // 创建并保存图表year,
//        createAndSaveChart(dataset, screwTypeId,  month, carType);
//    }

    /**
     * 从日期时间中提取天数（Lambda版本）
     */
//    private int extractDayFromDateTime(Date dateTime) {//LocalDateTime dateTime
//        return Optional.ofNullable(dateTime)
//                .map(Date::getDay)//Date.getDay() 方法返回的是星期几（0-6），而不是月份中的天数
////                .map(LocalDateTime::getDayOfMonth)
//                .orElse(0);
//    }
    /**
     * 从日期时间中提取天数（Lambda版本）- 修复版
     */
    private int extractDayFromDateTime(Date dateTime) {
        return Optional.ofNullable(dateTime)
                .map(date -> {
                    Calendar calendar = Calendar.getInstance();
                    calendar.setTime(date);
                    return calendar.get(Calendar.DAY_OF_MONTH);
                })
                .orElse(0);
    }

    /**
     * 计算抽样顺序（模拟你的抽样逻辑）
     */
    private int calculateSampleOrder(SampleScrew screw) {
        // 这里可以根据你的业务逻辑计算抽样顺序
        // 暂时使用简单的模4计算，你可以根据实际需求修改
        return (int) ((screw.getId() % 4) + 1);
    }

    /**
     * 创建数据集（Lambda版本）
     */
    private XYSeriesCollection createDataset(Map<Integer, Map<Integer, List<SampleScrew>>> dailyData) {
        XYSeriesCollection dataset = new XYSeriesCollection();

        // 为每个抽样顺序（1-4）创建数据系列
        IntStream.rangeClosed(1, 4).forEach(sampleOrder -> {
            XYSeries series = new XYSeries("第" + sampleOrder + "次抽样");

            // 按日期排序并添加数据点
            dailyData.entrySet().stream()
                    .sorted(Map.Entry.comparingByKey())
                    .forEach(entry -> {
                        int day = entry.getKey();
                        Map<Integer, List<SampleScrew>> sampleData = entry.getValue();

                        // 获取当天的对应抽样数据
                        sampleData.getOrDefault(sampleOrder, new ArrayList<>()).stream()
                                .findFirst() // 取第一个数据点
                                .ifPresent(screw ->
                                        series.add(day, screw.getTorque().doubleValue())
                                );
                    });

            dataset.addSeries(series);
        });

        return dataset;
    }

    /**
     * 创建并保存图表（Lambda版本）
     */
//    private void createAndSaveChart(XYSeriesCollection dataset, Long screwTypeId,
//                                    int year, int month, String carType, String outputDir) {
//        try {
//            // 创建图表
//            JFreeChart chart = ChartFactory.createXYLineChart(
//                    String.format("%s - 螺丝类型 %d - %d年%d月扭力抽样趋势", carType, screwTypeId, year, month),
//                    "日期 (日)",
//                    "扭力值 (N)",
//                    dataset,
//                    PlotOrientation.VERTICAL,
//                    true, true, false
//            );
//
//            // 自定义图表样式
//            customizeChart(chart);
//
//            // 保存图表
//            String fileName = String.format("%s_螺丝类型%d_%d年%d月抽样趋势图.png",
//                    carType, screwTypeId, year, month);
//            File outputFile = new File(outputDir, fileName);
//
//            ChartUtils.saveChartAsPNG(outputFile, chart, 1200, 800);
//            log.info("📊 已生成图表: {}", outputFile.getName());
//
//        } catch (Exception e) {
//            log.error("❌ 生成螺丝类型 {} 的图表失败: {}", screwTypeId, e.getMessage());
//        }
//    }

    /**
     * 自定义图表样式（Lambda版本）
     */
//    private void customizeChart(JFreeChart chart) {
//        // 设置颜色
//        Color[] lineColors = {
//                new Color(255, 0, 0),    // 红色
//                new Color(0, 0, 255),    // 蓝色
//                new Color(0, 128, 0),    // 绿色
//                new Color(255, 165, 0)   // 橙色
//        };
//
//        XYPlot plot = chart.getXYPlot();
//
//        // 设置背景
//        plot.setBackgroundPaint(Color.WHITE);
//        plot.setDomainGridlinePaint(Color.LIGHT_GRAY);
//        plot.setRangeGridlinePaint(Color.LIGHT_GRAY);
//
//        // 设置线条样式
//        XYLineAndShapeRenderer renderer = new XYLineAndShapeRenderer();
//        IntStream.range(0, 4).forEach(i -> {
//            renderer.setSeriesPaint(i, lineColors[i]);
//            renderer.setSeriesStroke(i, new BasicStroke(2.0f));
//            renderer.setSeriesShapesVisible(i, true);
//            renderer.setSeriesShape(i, new Ellipse2D.Double(-3, -3, 6, 6));
//        });
//        plot.setRenderer(renderer);
//
//        // 设置Y轴范围（18-38Nm）
//        Optional.of((NumberAxis) plot.getRangeAxis())
//                .ifPresent(axis -> axis.setRange(18.0, 38.0));
//
//        // 设置X轴范围（1-31日）
//        Optional.of((NumberAxis) plot.getDomainAxis())
//                .ifPresent(axis -> axis.setRange(1, 31));
//
//        // 设置字体
//        Optional.of(chart.getTitle())
//                .ifPresent(title -> title.setFont(new Font("微软雅黑", Font.BOLD, 16)));
//    }


    //新的写excel方法，取样4次
    private Map NewProcessCarType(String carType, String month) {
        System.out.println("手动导出excel");
        log.info("手动导出excel");
        LambdaQueryWrapper<SampleScrew> querySampleScrewWrapper = new LambdaQueryWrapper<>();
        querySampleScrewWrapper.like(SampleScrew::getScrewCreateTime, month);
        querySampleScrewWrapper.eq(SampleScrew::getCarType, carType);
        List<SampleScrew> sampleScrews = sampleScrewMapper.selectList(querySampleScrewWrapper);

        if (sampleScrews.isEmpty()) {
            System.out.println("没有找到前个月的" + carType + "车型");
//            return null;
        }

        //如果数据库里有凯美瑞的车型样本，就先把所有凯美瑞的车型查出来，然后每天每30台车取一粒螺丝扭力检测数据
        InputStream in = null;
        if(carType.equals(carTypeProperties.getCamry())) {
            in = this.getClass().getClassLoader()
                    .getResourceAsStream("template/"+ MessageConstant.camryFileName);
        }else if(carType.equals(carTypeProperties.getLevin())) {
            in = this.getClass().getClassLoader()
                    .getResourceAsStream("template/"+MessageConstant.levinFileName);
        }else {
            log.info("未知车型");
            return null;
        }
        //基于模板文件创建Excel文件
        //旧格式
        HSSFWorkbook excel = null;
        //新格式
//        XSSFWorkbook excel = null;
        try {
            POIFSFileSystem fs = new POIFSFileSystem(in);
            excel = new HSSFWorkbook(fs);
            //新格式
//            excel = new XSSFWorkbook(in);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        HSSFSheet YQSheet = excel.getSheet("右前门扭力");
        HSSFSheet ZQSheet = excel.getSheet("左前门扭力");
        HSSFSheet YHSheet = excel.getSheet("右后门扭力 (2)");
        HSSFSheet ZHSheet = excel.getSheet("左后门扭力");
        HSSFSheet CGSheet = excel.getSheet("发动机盖");

        if(carType.equals(carTypeProperties.getCamry())) {

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
//            int[][] filledCounts0 = new int[32][]; // 一个月最多31天，CarNum有N种
//            Map<String, Integer> filledCounts0 = new HashMap<>();
            Map<Integer, Integer> filledCounts0 = new HashMap<>(); // 类级变量，注意key是Integer类型


            //处理左前后门数据
            for (SampleScrew sampleScrew : sampleScrews) {

                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId >= 5) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 1) * 17; // 每个screwTypeId占据27行
                int rowNumber = 16 + rowOffset + filledCounts[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了4个数据
                if (filledCounts[day][screwTypeId] < 4) {
                    // 获取或创建行和单元格
                    Row row = ZQSheet.getRow(rowNumber);
                    if (row == null) {
                        row = ZQSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts[day][screwTypeId]++;
                }

                //新增填写车身部位抽取车辆的车身号
                //TODO 最后填充这一页抽取的螺丝的车身号第72到75行
                log.info("-------------最后填充这一页抽取的螺丝的车身号第72到75行------------");
//                int carNum = Integer.parseInt(sampleScrew.getCarNum());
                String carNum = sampleScrew.getCarNum();
                if (carNum == null || carNum.trim().isEmpty()) {
                    log.warn("CarNum为空或空白，跳过");
                    continue;
                }
                carNum = carNum.trim();
//                int rowNumber0 = 71 + filledCounts0[day][carNum]; // 从第71行开始填充，加上偏移量

//                // 检查是否已经填充了4个车身号数据
//                if (filledCounts0[day][carNum] < 4) {
//                    // 获取或创建行和单元格
//                    Row row = ZHSheet.getRow(rowNumber0);
//                    if (row == null) {
//                        row = ZQSheet.createRow(rowNumber0);
//                    }
//
//                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
//                    Cell cell = row.getCell(columnNumber);
//                    if (cell == null) {
//                        cell = row.createCell(columnNumber);
//                    }
//
//                    // 填充数据
//                    cell.setCellValue(sampleScrew.getCarNum());
//
//                    // 增加已填充计数
//                    filledCounts0[day][carNum]++;
//                }

                // 构造拼接键：用特殊分隔符（如"__"）避免冲突（关键！）
// 例：day=1、carNum="C123" → 键为"1__C123"；day=12、carNum="3" → 键为"12__3"
                // 2. 核心修改：按「day（列）」作为计数key，而非day+carNum
                Integer countKey = day; // key直接是日期（1~31），对应每一列
// 3. 获取当前列（day）已填充的总个数（无则默认0）
                int currentCount = filledCounts0.getOrDefault(countKey, 0);
//                String key = day + "__" + carNum;
//                int currentCount = filledCounts0.getOrDefault(key, 0);//.size();//
                if (currentCount < 4) {
                    int rowNumber0 = 71 + currentCount;
                    Row row = ZQSheet.getRow(rowNumber0);
                    if (row == null) {
                        row = ZQSheet.createRow(rowNumber0);
                    }

                    int columnNumber = 3 + day;
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    cell.setCellValue(carNum);
                    filledCounts0.put(countKey, currentCount + 1);
                    log.info("列：{}（day={}）已填充{}个数据，当前填充carNum：{}，行号：{}",
                            columnNumber, day, currentCount + 1, carNum, rowNumber0);
                }

            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts2 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            Map<Integer, Integer> filledCounts02 = new HashMap<>(); // 类级变量，注意key是Integer类型

            //处理左后门数据
            for (SampleScrew sampleScrew : sampleScrews) {

//            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 4 || screwTypeId >= 9) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 5) * 17; // 每个screwTypeId占据27行
                int rowNumber = 16 + rowOffset + filledCounts2[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//            log.info("filledCounts[day][screwTypeId]是:"+filledCounts2[day][screwTypeId]);
                if (filledCounts2[day][screwTypeId] < 4) {
                    // 获取或创建行和单元格
                    Row row = ZHSheet.getRow(rowNumber);
//                log.info("第几行"+rowNumber);
                    if (row == null) {
                        row = ZHSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts2[day][screwTypeId]++;
                }

                //新增填写车身部位抽取车辆的车身号
                //TODO 最后填充这一页抽取的螺丝的车身号第72到75行
                log.info("-------------最后填充这一页抽取的螺丝的车身号第72到75行------------");
//                int carNum = Integer.parseInt(sampleScrew.getCarNum());
                String carNum = sampleScrew.getCarNum();
                if (carNum == null || carNum.trim().isEmpty()) {
                    log.warn("CarNum为空或空白，跳过");
                    continue;
                }
                carNum = carNum.trim();
                // 构造拼接键：用特殊分隔符（如"__"）避免冲突（关键！）
// 例：day=1、carNum="C123" → 键为"1__C123"；day=12、carNum="3" → 键为"12__3"
                // 2. 核心修改：按「day（列）」作为计数key，而非day+carNum
                Integer countKey = day; // key直接是日期（1~31），对应每一列
// 3. 获取当前列（day）已填充的总个数（无则默认0）
                int currentCount = filledCounts02.getOrDefault(countKey, 0);
//                String key = day + "__" + carNum;
//                int currentCount = filledCounts0.getOrDefault(key, 0);//.size();//
                if (currentCount < 4) {
                    int rowNumber0 = 71 + currentCount;
                    Row row = ZHSheet.getRow(rowNumber0);
                    if (row == null) {
                        row = ZHSheet.createRow(rowNumber0);
                    }

                    int columnNumber = 3 + day;
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    cell.setCellValue(carNum);
                    filledCounts02.put(countKey, currentCount + 1);
                    log.info("列：{}（day={}）已填充{}个数据，当前填充carNum：{}，行号：{}",
                            columnNumber, day, currentCount + 1, carNum, rowNumber0);
                }
            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts3 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            Map<Integer, Integer> filledCounts03 = new HashMap<>(); // 类级变量，注意key是Integer类型

            //处理右前门数据
            for (SampleScrew sampleScrew : sampleScrews) {

//            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 8 || screwTypeId >= 13) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 9) * 17; // 每个screwTypeId占据27行
                int rowNumber = 16 + rowOffset + filledCounts3[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//            log.info("filledCounts[day][screwTypeId]是:"+filledCounts3[day][screwTypeId]);
                if (filledCounts3[day][screwTypeId] < 4) {
                    // 获取或创建行和单元格
                    Row row = YQSheet.getRow(rowNumber);
//                log.info("第几行"+rowNumber);
                    if (row == null) {
                        row = YQSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts3[day][screwTypeId]++;
                }

                //新增填写车身部位抽取车辆的车身号
                //TODO 最后填充这一页抽取的螺丝的车身号第72到75行
                log.info("-------------最后填充这一页抽取的螺丝的车身号第72到75行------------");
//                int carNum = Integer.parseInt(sampleScrew.getCarNum());
                String carNum = sampleScrew.getCarNum();
                if (carNum == null || carNum.trim().isEmpty()) {
                    log.warn("CarNum为空或空白，跳过");
                    continue;
                }
                carNum = carNum.trim();
                // 构造拼接键：用特殊分隔符（如"__"）避免冲突（关键！）
// 例：day=1、carNum="C123" → 键为"1__C123"；day=12、carNum="3" → 键为"12__3"
                // 2. 核心修改：按「day（列）」作为计数key，而非day+carNum
                Integer countKey = day; // key直接是日期（1~31），对应每一列
// 3. 获取当前列（day）已填充的总个数（无则默认0）
                int currentCount = filledCounts03.getOrDefault(countKey, 0);
//                String key = day + "__" + carNum;
//                int currentCount = filledCounts0.getOrDefault(key, 0);//.size();//
                if (currentCount < 4) {
                    int rowNumber0 = 71 + currentCount;
                    Row row = YQSheet.getRow(rowNumber0);
                    if (row == null) {
                        row = YQSheet.createRow(rowNumber0);
                    }

                    int columnNumber = 3 + day;
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    cell.setCellValue(carNum);
                    filledCounts03.put(countKey, currentCount + 1);
                    log.info("列：{}（day={}）已填充{}个数据，当前填充carNum：{}，行号：{}",
                            columnNumber, day, currentCount + 1, carNum, rowNumber0);
                }
            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts4 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            Map<Integer, Integer> filledCounts04 = new HashMap<>(); // 类级变量，注意key是Integer类型

            //处理右后门数据
            for (SampleScrew sampleScrew : sampleScrews) {

//            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 12 || screwTypeId >= 17) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 13) * 17; // 每个screwTypeId占据27行
                int rowNumber = 16 + rowOffset + filledCounts4[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//                log.info("filledCounts[day][screwTypeId]是:" + filledCounts4[day][screwTypeId]);
                if (filledCounts4[day][screwTypeId] < 4) {
                    // 获取或创建行和单元格
                    Row row = YHSheet.getRow(rowNumber);
//                    log.info("第几行" + rowNumber);
                    if (row == null) {
                        row = YHSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts4[day][screwTypeId]++;
                }

                //新增填写车身部位抽取车辆的车身号
                //TODO 最后填充这一页抽取的螺丝的车身号第72到75行
                log.info("-------------最后填充这一页抽取的螺丝的车身号第72到75行------------");
//                int carNum = Integer.parseInt(sampleScrew.getCarNum());
                String carNum = sampleScrew.getCarNum();
                if (carNum == null || carNum.trim().isEmpty()) {
                    log.warn("CarNum为空或空白，跳过");
                    continue;
                }
                carNum = carNum.trim();
                // 构造拼接键：用特殊分隔符（如"__"）避免冲突（关键！）
// 例：day=1、carNum="C123" → 键为"1__C123"；day=12、carNum="3" → 键为"12__3"
                // 2. 核心修改：按「day（列）」作为计数key，而非day+carNum
                Integer countKey = day; // key直接是日期（1~31），对应每一列
// 3. 获取当前列（day）已填充的总个数（无则默认0）
                int currentCount = filledCounts04.getOrDefault(countKey, 0);
//                String key = day + "__" + carNum;
//                int currentCount = filledCounts0.getOrDefault(key, 0);//.size();//
                if (currentCount < 4) {
                    int rowNumber0 = 71 + currentCount;
                    Row row = YHSheet.getRow(rowNumber0);
                    if (row == null) {
                        row = YHSheet.createRow(rowNumber0);
                    }

                    int columnNumber = 3 + day;
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    cell.setCellValue(carNum);
                    filledCounts04.put(countKey, currentCount + 1);
                    log.info("列：{}（day={}）已填充{}个数据，当前填充carNum：{}，行号：{}",
                            columnNumber, day, currentCount + 1, carNum, rowNumber0);
                }
            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts5 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            Map<Integer, Integer> filledCounts05 = new HashMap<>(); // 类级变量，注意key是Integer类型

            //处理车盖数据
            for (SampleScrew sampleScrew : sampleScrews) {

//            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 16 || screwTypeId >= 21) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 17) * 15; // 每个screwTypeId之间相隔25行
                int rowNumber = 16 + rowOffset + filledCounts5[day][screwTypeId]; // 从第16行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//                log.info("filledCounts[day][screwTypeId]是:" + filledCounts5[day][screwTypeId]);
                if (filledCounts5[day][screwTypeId] < 2) {
                    // 获取或创建行和单元格
                    Row row = CGSheet.getRow(rowNumber);
//                    log.info("第几行" + rowNumber);
                    if (row == null) {
                        row = CGSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts5[day][screwTypeId]++;
                }

                //新增填写车身部位抽取车辆的车身号
                //TODO 最后填充这一页抽取的螺丝的车身号第64到65行
                log.info("-------------最后填充这一页抽取的螺丝的车身号第64到65行------------");
//                int carNum = Integer.parseInt(sampleScrew.getCarNum());
                String carNum = sampleScrew.getCarNum();
                if (carNum == null || carNum.trim().isEmpty()) {
                    log.warn("CarNum为空或空白，跳过");
                    continue;
                }
                carNum = carNum.trim();
                // 构造拼接键：用特殊分隔符（如"__"）避免冲突（关键！）
// 例：day=1、carNum="C123" → 键为"1__C123"；day=12、carNum="3" → 键为"12__3"
                // 2. 核心修改：按「day（列）」作为计数key，而非day+carNum
                Integer countKey = day; // key直接是日期（1~31），对应每一列
// 3. 获取当前列（day）已填充的总个数（无则默认0）
                int currentCount = filledCounts05.getOrDefault(countKey, 0);
//                String key = day + "__" + carNum;
//                int currentCount = filledCounts0.getOrDefault(key, 0);//.size();//
                if (currentCount < 2) {
                    int rowNumber0 = 63 + currentCount;
                    Row row = CGSheet.getRow(rowNumber0);
                    if (row == null) {
                        row = CGSheet.createRow(rowNumber0);
                    }

                    int columnNumber = 3 + day;
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    cell.setCellValue(carNum);
                    filledCounts05.put(countKey, currentCount + 1);
                    log.info("列：{}（day={}）已填充{}个数据，当前填充carNum：{}，行号：{}",
                            columnNumber, day, currentCount + 1, carNum, rowNumber0);
                }

            }
        }
        //TODO 未修改
        else if(carType.equals(carTypeProperties.getLevin())) {
            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            //处理左前后门数据
            for (SampleScrew sampleScrew : sampleScrews) {

                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId >= 5) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 1) * 21; // 每个screwTypeId占据27行
                int rowNumber = 16 + rowOffset + filledCounts[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
                if (filledCounts[day][screwTypeId] < 8) {
                    // 获取或创建行和单元格
                    Row row = ZQSheet.getRow(rowNumber);
                    if (row == null) {
                        row = ZQSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts[day][screwTypeId]++;
                }
            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts2 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            //处理左后门数据
            for (SampleScrew sampleScrew : sampleScrews) {
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 4 || screwTypeId >= 9) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 5) * 21; // 每个screwTypeId占据27行
                int rowNumber = 16 + rowOffset + filledCounts2[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//            log.info("filledCounts[day][screwTypeId]是:"+filledCounts2[day][screwTypeId]);
                if (filledCounts2[day][screwTypeId] < 8) {
                    // 获取或创建行和单元格
                    Row row = ZHSheet.getRow(rowNumber);
                    if (row == null) {
                        row = ZHSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts2[day][screwTypeId]++;
                }
            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts3 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            //处理右前门数据
            for (SampleScrew sampleScrew : sampleScrews) {

//            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 8 || screwTypeId >= 13) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 9) * 21; // 每个screwTypeId占据27行
                int rowNumber = 16 + rowOffset + filledCounts3[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//            log.info("filledCounts[day][screwTypeId]是:"+filledCounts3[day][screwTypeId]);
                if (filledCounts3[day][screwTypeId] < 8) {
                    // 获取或创建行和单元格
                    Row row = YQSheet.getRow(rowNumber);
                    if (row == null) {
                        row = YQSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts3[day][screwTypeId]++;
                }
            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts4 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            //处理右后门数据
            for (SampleScrew sampleScrew : sampleScrews) {

                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 12 || screwTypeId >= 17) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 13) * 21; // 每个screwTypeId占据27行
                int rowNumber = 16 + rowOffset + filledCounts4[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//                log.info("filledCounts[day][screwTypeId]是:" + filledCounts4[day][screwTypeId]);
                if (filledCounts4[day][screwTypeId] < 8) {
                    // 获取或创建行和单元格
                    Row row = YHSheet.getRow(rowNumber);
//                    log.info("第几行" + rowNumber);
                    if (row == null) {
                        row = YHSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts4[day][screwTypeId]++;
                }
            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts5 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            //处理车盖数据
            for (SampleScrew sampleScrew : sampleScrews) {

//            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 16 || screwTypeId >= 21) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 17) * 25; // 每个screwTypeId之间相隔25行
                int rowNumber = 16 + rowOffset + filledCounts5[day][screwTypeId]; // 从第16行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//                log.info("filledCounts[day][screwTypeId]是:" + filledCounts5[day][screwTypeId]);
                if (filledCounts5[day][screwTypeId] < 8) {
                    // 获取或创建行和单元格
                    Row row = CGSheet.getRow(rowNumber);
//                    log.info("第几行" + rowNumber);
                    if (row == null) {
                        row = CGSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts5[day][screwTypeId]++;
                }
            }
        }else {
            log.info("未知车型");
            return null;
        }

        //生成并往excel文件里写入图表
        // 在生成 Excel 后，同时生成图表
//        try {
//            generateScrewSamplingCharts(carType, month);
//        } catch (Exception e) {
//            log.warn("生成螺丝抽样图表时出现异常: {}", e.getMessage());
//        }

        String fileName = null;
        if(carType.equals(carTypeProperties.getCamry())){
            fileName = "(" + month + ")" + MessageConstant.camryFileName; // 指定路径，同名就会会覆盖之前生成的文件
        }else if(carType.equals(carTypeProperties.getLevin())){
            fileName = "(" + month + ")" + MessageConstant.levinFileName;
        }
        Map map = new HashMap();
        map.put("fileName", fileName);
        map.put("excel", excel);
        return map;
    }


//    //新的写excel方法，取样4次
//    private Map NewProcessCarType(String carType, String month) {
//        System.out.println("手动导出excel");
//        log.info("手动导出excel");
//        LambdaQueryWrapper<SampleScrew> querySampleScrewWrapper = new LambdaQueryWrapper<>();
//        querySampleScrewWrapper.like(SampleScrew::getScrewCreateTime, month);
//        querySampleScrewWrapper.eq(SampleScrew::getCarType, carType);
//        List<SampleScrew> sampleScrews = sampleScrewMapper.selectList(querySampleScrewWrapper);
//
//        if (sampleScrews.isEmpty()) {
//            System.out.println("没有找到前个月的" + carType + "车型");
////            return null;
//        }
//
//        //如果数据库里有凯美瑞的车型样本，就先把所有凯美瑞的车型查出来，然后每天每30台车取一粒螺丝扭力检测数据
//        InputStream in = null;
//        if(carType.equals(carTypeProperties.getCamry())) {
//            in = this.getClass().getClassLoader()
//                    .getResourceAsStream("template/"+ MessageConstant.camryFileName);
//        }else if(carType.equals(carTypeProperties.getLevin())) {
//            in = this.getClass().getClassLoader()
//                    .getResourceAsStream("template/"+MessageConstant.levinFileName);
//        }else {
//            log.info("未知车型");
//            return null;
//        }
//        //基于模板文件创建Excel文件
//        //旧格式
//        HSSFWorkbook excel = null;
//        //新格式
////        XSSFWorkbook excel = null;
//        try {
//            POIFSFileSystem fs = new POIFSFileSystem(in);
//            excel = new HSSFWorkbook(fs);
//            //新格式
////            excel = new XSSFWorkbook(in);
//        } catch (IOException e) {
//            throw new RuntimeException(e);
//        }
//        HSSFSheet YQSheet = excel.getSheet("右前门扭力");
//        HSSFSheet ZQSheet = excel.getSheet("左前门扭力");
//        HSSFSheet YHSheet = excel.getSheet("右后门扭力 (2)");
//        HSSFSheet ZHSheet = excel.getSheet("左后门扭力");
//        HSSFSheet CGSheet = excel.getSheet("发动机盖");
//
//        if(carType.equals(carTypeProperties.getCamry())) {
//
//            // 用于跟踪每天每种ScrewTypeId已填充的数量
//            int[][] filledCounts = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
////            int[][] filledCounts0 = new int[32][]; // 一个月最多31天，CarNum有N种
////            Map<String, Integer> filledCounts0 = new HashMap<>();
//            Map<Integer, Integer> filledCounts0 = new HashMap<>(); // 类级变量，注意key是Integer类型
//
//
//            //处理左前后门数据
//            for (SampleScrew sampleScrew : sampleScrews) {
//
//                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
////            log.info("createTime是" + createTime);
//// 查找日期和时间的分隔符（空格）的位置
//                int spaceIndex = createTime.indexOf(' ');
//// 查找日期部分中最后一个短横线的位置
//                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
//// 从最后一个短横线后开始截取，直到空格前，即为日部分
//                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
////            log.info("dayStr是"+dayStr);
//// 将日部分转换为整数
//                int day = Integer.parseInt(dayStr);
////            log.info("day是" + day);
//
//                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
//                if (screwTypeId >= 5) {
//                    continue;
//                }
//
//                // 计算行号和列号
//                int rowOffset = (screwTypeId - 1) * 17; // 每个screwTypeId占据27行
//                int rowNumber = 16 + rowOffset + filledCounts[day][screwTypeId]; // 从第22行开始填充，加上偏移量
//
//                // 检查是否已经填充了4个数据
//                if (filledCounts[day][screwTypeId] < 4) {
//                    // 获取或创建行和单元格
//                    Row row = ZQSheet.getRow(rowNumber);
//                    if (row == null) {
//                        row = ZQSheet.createRow(rowNumber);
//                    }
//
//                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
//                    Cell cell = row.getCell(columnNumber);
//                    if (cell == null) {
//                        cell = row.createCell(columnNumber);
//                    }
//
//                    // 填充数据
//                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());
//
//                    // 增加已填充计数
//                    filledCounts[day][screwTypeId]++;
//                }
//
//                //新增填写车身部位抽取车辆的车身号
//                //TODO 最后填充这一页抽取的螺丝的车身号第72到75行
//                log.info("-------------最后填充这一页抽取的螺丝的车身号第72到75行------------");
////                int carNum = Integer.parseInt(sampleScrew.getCarNum());
//                String carNum = sampleScrew.getCarNum();
//                if (carNum == null || carNum.trim().isEmpty()) {
//                    log.warn("CarNum为空或空白，跳过");
//                    continue;
//                }
//                carNum = carNum.trim();
////                int rowNumber0 = 71 + filledCounts0[day][carNum]; // 从第71行开始填充，加上偏移量
//
////                // 检查是否已经填充了4个车身号数据
////                if (filledCounts0[day][carNum] < 4) {
////                    // 获取或创建行和单元格
////                    Row row = ZHSheet.getRow(rowNumber0);
////                    if (row == null) {
////                        row = ZQSheet.createRow(rowNumber0);
////                    }
////
////                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
////                    Cell cell = row.getCell(columnNumber);
////                    if (cell == null) {
////                        cell = row.createCell(columnNumber);
////                    }
////
////                    // 填充数据
////                    cell.setCellValue(sampleScrew.getCarNum());
////
////                    // 增加已填充计数
////                    filledCounts0[day][carNum]++;
////                }
//
//                // 构造拼接键：用特殊分隔符（如"__"）避免冲突（关键！）
//// 例：day=1、carNum="C123" → 键为"1__C123"；day=12、carNum="3" → 键为"12__3"
//                // 2. 核心修改：按「day（列）」作为计数key，而非day+carNum
//                Integer countKey = day; // key直接是日期（1~31），对应每一列
//// 3. 获取当前列（day）已填充的总个数（无则默认0）
//                int currentCount = filledCounts0.getOrDefault(countKey, 0);
////                String key = day + "__" + carNum;
////                int currentCount = filledCounts0.getOrDefault(key, 0);//.size();//
//                if (currentCount < 4) {
//                    int rowNumber0 = 71 + currentCount;
//                    Row row = ZQSheet.getRow(rowNumber0);
//                    if (row == null) {
//                        row = ZQSheet.createRow(rowNumber0);
//                    }
//
//                    int columnNumber = 3 + day;
//                    Cell cell = row.getCell(columnNumber);
//                    if (cell == null) {
//                        cell = row.createCell(columnNumber);
//                    }
//
//                    cell.setCellValue(carNum);
//                    filledCounts0.put(countKey, currentCount + 1);
//                    log.info("列：{}（day={}）已填充{}个数据，当前填充carNum：{}，行号：{}",
//                            columnNumber, day, currentCount + 1, carNum, rowNumber0);
//                }
//
//            }
//
//            // 用于跟踪每天每种ScrewTypeId已填充的数量
//            int[][] filledCounts2 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
//            Map<Integer, Integer> filledCounts02 = new HashMap<>(); // 类级变量，注意key是Integer类型
//
//            //处理左后门数据
//            for (SampleScrew sampleScrew : sampleScrews) {
//
////            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
//                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
////            log.info("createTime是" + createTime);
//// 查找日期和时间的分隔符（空格）的位置
//                int spaceIndex = createTime.indexOf(' ');
//// 查找日期部分中最后一个短横线的位置
//                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
//// 从最后一个短横线后开始截取，直到空格前，即为日部分
//                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
////            log.info("dayStr是"+dayStr);
//// 将日部分转换为整数
//                int day = Integer.parseInt(dayStr);
////            log.info("day是" + day);
//
//                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
//                if (screwTypeId <= 4 || screwTypeId >= 9) {
//                    continue;
//                }
//
//                // 计算行号和列号
//                int rowOffset = (screwTypeId - 5) * 17; // 每个screwTypeId占据27行
//                int rowNumber = 16 + rowOffset + filledCounts2[day][screwTypeId]; // 从第22行开始填充，加上偏移量
//
//                // 检查是否已经填充了8个数据
////            log.info("filledCounts[day][screwTypeId]是:"+filledCounts2[day][screwTypeId]);
//                if (filledCounts2[day][screwTypeId] < 4) {
//                    // 获取或创建行和单元格
//                    Row row = ZHSheet.getRow(rowNumber);
////                log.info("第几行"+rowNumber);
//                    if (row == null) {
//                        row = ZHSheet.createRow(rowNumber);
//                    }
//
//                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
//                    Cell cell = row.getCell(columnNumber);
//                    if (cell == null) {
//                        cell = row.createCell(columnNumber);
//                    }
//
//                    // 填充数据
//                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());
//
//                    // 增加已填充计数
//                    filledCounts2[day][screwTypeId]++;
//                }
//
//                //新增填写车身部位抽取车辆的车身号
//                //TODO 最后填充这一页抽取的螺丝的车身号第72到75行
//                log.info("-------------最后填充这一页抽取的螺丝的车身号第72到75行------------");
////                int carNum = Integer.parseInt(sampleScrew.getCarNum());
//                String carNum = sampleScrew.getCarNum();
//                if (carNum == null || carNum.trim().isEmpty()) {
//                    log.warn("CarNum为空或空白，跳过");
//                    continue;
//                }
//                carNum = carNum.trim();
//                // 构造拼接键：用特殊分隔符（如"__"）避免冲突（关键！）
//// 例：day=1、carNum="C123" → 键为"1__C123"；day=12、carNum="3" → 键为"12__3"
//                // 2. 核心修改：按「day（列）」作为计数key，而非day+carNum
//                Integer countKey = day; // key直接是日期（1~31），对应每一列
//// 3. 获取当前列（day）已填充的总个数（无则默认0）
//                int currentCount = filledCounts02.getOrDefault(countKey, 0);
////                String key = day + "__" + carNum;
////                int currentCount = filledCounts0.getOrDefault(key, 0);//.size();//
//                if (currentCount < 4) {
//                    int rowNumber0 = 71 + currentCount;
//                    Row row = ZHSheet.getRow(rowNumber0);
//                    if (row == null) {
//                        row = ZHSheet.createRow(rowNumber0);
//                    }
//
//                    int columnNumber = 3 + day;
//                    Cell cell = row.getCell(columnNumber);
//                    if (cell == null) {
//                        cell = row.createCell(columnNumber);
//                    }
//
//                    cell.setCellValue(carNum);
//                    filledCounts02.put(countKey, currentCount + 1);
//                    log.info("列：{}（day={}）已填充{}个数据，当前填充carNum：{}，行号：{}",
//                            columnNumber, day, currentCount + 1, carNum, rowNumber0);
//                }
//            }
//
//            // 用于跟踪每天每种ScrewTypeId已填充的数量
//            int[][] filledCounts3 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
//            Map<Integer, Integer> filledCounts03 = new HashMap<>(); // 类级变量，注意key是Integer类型
//
//            //处理右前门数据
//            for (SampleScrew sampleScrew : sampleScrews) {
//
////            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
//                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
////            log.info("createTime是" + createTime);
//// 查找日期和时间的分隔符（空格）的位置
//                int spaceIndex = createTime.indexOf(' ');
//// 查找日期部分中最后一个短横线的位置
//                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
//// 从最后一个短横线后开始截取，直到空格前，即为日部分
//                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
////            log.info("dayStr是"+dayStr);
//// 将日部分转换为整数
//                int day = Integer.parseInt(dayStr);
////            log.info("day是" + day);
//
//                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
//                if (screwTypeId <= 8 || screwTypeId >= 13) {
//                    continue;
//                }
//
//                // 计算行号和列号
//                int rowOffset = (screwTypeId - 9) * 17; // 每个screwTypeId占据27行
//                int rowNumber = 16 + rowOffset + filledCounts3[day][screwTypeId]; // 从第22行开始填充，加上偏移量
//
//                // 检查是否已经填充了8个数据
////            log.info("filledCounts[day][screwTypeId]是:"+filledCounts3[day][screwTypeId]);
//                if (filledCounts3[day][screwTypeId] < 4) {
//                    // 获取或创建行和单元格
//                    Row row = YQSheet.getRow(rowNumber);
////                log.info("第几行"+rowNumber);
//                    if (row == null) {
//                        row = YQSheet.createRow(rowNumber);
//                    }
//
//                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
//                    Cell cell = row.getCell(columnNumber);
//                    if (cell == null) {
//                        cell = row.createCell(columnNumber);
//                    }
//
//                    // 填充数据
//                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());
//
//                    // 增加已填充计数
//                    filledCounts3[day][screwTypeId]++;
//                }
//
//                //新增填写车身部位抽取车辆的车身号
//                //TODO 最后填充这一页抽取的螺丝的车身号第72到75行
//                log.info("-------------最后填充这一页抽取的螺丝的车身号第72到75行------------");
////                int carNum = Integer.parseInt(sampleScrew.getCarNum());
//                String carNum = sampleScrew.getCarNum();
//                if (carNum == null || carNum.trim().isEmpty()) {
//                    log.warn("CarNum为空或空白，跳过");
//                    continue;
//                }
//                carNum = carNum.trim();
//                // 构造拼接键：用特殊分隔符（如"__"）避免冲突（关键！）
//// 例：day=1、carNum="C123" → 键为"1__C123"；day=12、carNum="3" → 键为"12__3"
//                // 2. 核心修改：按「day（列）」作为计数key，而非day+carNum
//                Integer countKey = day; // key直接是日期（1~31），对应每一列
//// 3. 获取当前列（day）已填充的总个数（无则默认0）
//                int currentCount = filledCounts03.getOrDefault(countKey, 0);
////                String key = day + "__" + carNum;
////                int currentCount = filledCounts0.getOrDefault(key, 0);//.size();//
//                if (currentCount < 4) {
//                    int rowNumber0 = 71 + currentCount;
//                    Row row = YQSheet.getRow(rowNumber0);
//                    if (row == null) {
//                        row = YQSheet.createRow(rowNumber0);
//                    }
//
//                    int columnNumber = 3 + day;
//                    Cell cell = row.getCell(columnNumber);
//                    if (cell == null) {
//                        cell = row.createCell(columnNumber);
//                    }
//
//                    cell.setCellValue(carNum);
//                    filledCounts03.put(countKey, currentCount + 1);
//                    log.info("列：{}（day={}）已填充{}个数据，当前填充carNum：{}，行号：{}",
//                            columnNumber, day, currentCount + 1, carNum, rowNumber0);
//                }
//            }
//
//            // 用于跟踪每天每种ScrewTypeId已填充的数量
//            int[][] filledCounts4 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
//            Map<Integer, Integer> filledCounts04 = new HashMap<>(); // 类级变量，注意key是Integer类型
//
//            //处理右后门数据
//            for (SampleScrew sampleScrew : sampleScrews) {
//
////            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
//                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
////            log.info("createTime是" + createTime);
//// 查找日期和时间的分隔符（空格）的位置
//                int spaceIndex = createTime.indexOf(' ');
//// 查找日期部分中最后一个短横线的位置
//                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
//// 从最后一个短横线后开始截取，直到空格前，即为日部分
//                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
////            log.info("dayStr是"+dayStr);
//// 将日部分转换为整数
//                int day = Integer.parseInt(dayStr);
////            log.info("day是" + day);
//
//                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
//                if (screwTypeId <= 12 || screwTypeId >= 17) {
//                    continue;
//                }
//
//                // 计算行号和列号
//                int rowOffset = (screwTypeId - 13) * 17; // 每个screwTypeId占据27行
//                int rowNumber = 16 + rowOffset + filledCounts4[day][screwTypeId]; // 从第22行开始填充，加上偏移量
//
//                // 检查是否已经填充了8个数据
////                log.info("filledCounts[day][screwTypeId]是:" + filledCounts4[day][screwTypeId]);
//                if (filledCounts4[day][screwTypeId] < 4) {
//                    // 获取或创建行和单元格
//                    Row row = YHSheet.getRow(rowNumber);
////                    log.info("第几行" + rowNumber);
//                    if (row == null) {
//                        row = YHSheet.createRow(rowNumber);
//                    }
//
//                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
//                    Cell cell = row.getCell(columnNumber);
//                    if (cell == null) {
//                        cell = row.createCell(columnNumber);
//                    }
//
//                    // 填充数据
//                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());
//
//                    // 增加已填充计数
//                    filledCounts4[day][screwTypeId]++;
//                }
//
//                //新增填写车身部位抽取车辆的车身号
//                //TODO 最后填充这一页抽取的螺丝的车身号第72到75行
//                log.info("-------------最后填充这一页抽取的螺丝的车身号第72到75行------------");
////                int carNum = Integer.parseInt(sampleScrew.getCarNum());
//                String carNum = sampleScrew.getCarNum();
//                if (carNum == null || carNum.trim().isEmpty()) {
//                    log.warn("CarNum为空或空白，跳过");
//                    continue;
//                }
//                carNum = carNum.trim();
//                // 构造拼接键：用特殊分隔符（如"__"）避免冲突（关键！）
//// 例：day=1、carNum="C123" → 键为"1__C123"；day=12、carNum="3" → 键为"12__3"
//                // 2. 核心修改：按「day（列）」作为计数key，而非day+carNum
//                Integer countKey = day; // key直接是日期（1~31），对应每一列
//// 3. 获取当前列（day）已填充的总个数（无则默认0）
//                int currentCount = filledCounts04.getOrDefault(countKey, 0);
////                String key = day + "__" + carNum;
////                int currentCount = filledCounts0.getOrDefault(key, 0);//.size();//
//                if (currentCount < 4) {
//                    int rowNumber0 = 71 + currentCount;
//                    Row row = YHSheet.getRow(rowNumber0);
//                    if (row == null) {
//                        row = YHSheet.createRow(rowNumber0);
//                    }
//
//                    int columnNumber = 3 + day;
//                    Cell cell = row.getCell(columnNumber);
//                    if (cell == null) {
//                        cell = row.createCell(columnNumber);
//                    }
//
//                    cell.setCellValue(carNum);
//                    filledCounts04.put(countKey, currentCount + 1);
//                    log.info("列：{}（day={}）已填充{}个数据，当前填充carNum：{}，行号：{}",
//                            columnNumber, day, currentCount + 1, carNum, rowNumber0);
//                }
//            }
//
//            // 用于跟踪每天每种ScrewTypeId已填充的数量
//            int[][] filledCounts5 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
//            Map<Integer, Integer> filledCounts05 = new HashMap<>(); // 类级变量，注意key是Integer类型
//
//            //处理车盖数据
//            for (SampleScrew sampleScrew : sampleScrews) {
//
////            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
//                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
////            log.info("createTime是" + createTime);
//// 查找日期和时间的分隔符（空格）的位置
//                int spaceIndex = createTime.indexOf(' ');
//// 查找日期部分中最后一个短横线的位置
//                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
//// 从最后一个短横线后开始截取，直到空格前，即为日部分
//                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
////            log.info("dayStr是"+dayStr);
//// 将日部分转换为整数
//                int day = Integer.parseInt(dayStr);
////            log.info("day是" + day);
//
//                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
//                if (screwTypeId <= 16 || screwTypeId >= 21) {
//                    continue;
//                }
//
//                // 计算行号和列号
//                int rowOffset = (screwTypeId - 17) * 15; // 每个screwTypeId之间相隔25行
//                int rowNumber = 16 + rowOffset + filledCounts5[day][screwTypeId]; // 从第16行开始填充，加上偏移量
//
//                // 检查是否已经填充了8个数据
////                log.info("filledCounts[day][screwTypeId]是:" + filledCounts5[day][screwTypeId]);
//                if (filledCounts5[day][screwTypeId] < 2) {
//                    // 获取或创建行和单元格
//                    Row row = CGSheet.getRow(rowNumber);
////                    log.info("第几行" + rowNumber);
//                    if (row == null) {
//                        row = CGSheet.createRow(rowNumber);
//                    }
//
//                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
//                    Cell cell = row.getCell(columnNumber);
//                    if (cell == null) {
//                        cell = row.createCell(columnNumber);
//                    }
//
//                    // 填充数据
//                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());
//
//                    // 增加已填充计数
//                    filledCounts5[day][screwTypeId]++;
//                }
//
//                //新增填写车身部位抽取车辆的车身号
//                //TODO 最后填充这一页抽取的螺丝的车身号第64到65行
//                log.info("-------------最后填充这一页抽取的螺丝的车身号第64到65行------------");
////                int carNum = Integer.parseInt(sampleScrew.getCarNum());
//                String carNum = sampleScrew.getCarNum();
//                if (carNum == null || carNum.trim().isEmpty()) {
//                    log.warn("CarNum为空或空白，跳过");
//                    continue;
//                }
//                carNum = carNum.trim();
//                // 构造拼接键：用特殊分隔符（如"__"）避免冲突（关键！）
//// 例：day=1、carNum="C123" → 键为"1__C123"；day=12、carNum="3" → 键为"12__3"
//                // 2. 核心修改：按「day（列）」作为计数key，而非day+carNum
//                Integer countKey = day; // key直接是日期（1~31），对应每一列
//// 3. 获取当前列（day）已填充的总个数（无则默认0）
//                int currentCount = filledCounts05.getOrDefault(countKey, 0);
////                String key = day + "__" + carNum;
////                int currentCount = filledCounts0.getOrDefault(key, 0);//.size();//
//                if (currentCount < 2) {
//                    int rowNumber0 = 63 + currentCount;
//                    Row row = CGSheet.getRow(rowNumber0);
//                    if (row == null) {
//                        row = CGSheet.createRow(rowNumber0);
//                    }
//
//                    int columnNumber = 3 + day;
//                    Cell cell = row.getCell(columnNumber);
//                    if (cell == null) {
//                        cell = row.createCell(columnNumber);
//                    }
//
//                    cell.setCellValue(carNum);
//                    filledCounts05.put(countKey, currentCount + 1);
//                    log.info("列：{}（day={}）已填充{}个数据，当前填充carNum：{}，行号：{}",
//                            columnNumber, day, currentCount + 1, carNum, rowNumber0);
//                }
//
//            }
//        }
//        //TODO 未修改
//        else if(carType.equals(carTypeProperties.getLevin())) {
//            // 用于跟踪每天每种ScrewTypeId已填充的数量
//            int[][] filledCounts = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
//            //处理左前后门数据
//            for (SampleScrew sampleScrew : sampleScrews) {
//
//                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//                int spaceIndex = createTime.indexOf(' ');
//// 查找日期部分中最后一个短横线的位置
//                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
//// 从最后一个短横线后开始截取，直到空格前，即为日部分
//                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
////            log.info("dayStr是"+dayStr);
//// 将日部分转换为整数
//                int day = Integer.parseInt(dayStr);
////            log.info("day是" + day);
//
//                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
//                if (screwTypeId >= 5) {
//                    continue;
//                }
//
//                // 计算行号和列号
//                int rowOffset = (screwTypeId - 1) * 21; // 每个screwTypeId占据27行
//                int rowNumber = 16 + rowOffset + filledCounts[day][screwTypeId]; // 从第22行开始填充，加上偏移量
//
//                // 检查是否已经填充了8个数据
//                if (filledCounts[day][screwTypeId] < 8) {
//                    // 获取或创建行和单元格
//                    Row row = ZQSheet.getRow(rowNumber);
//                    if (row == null) {
//                        row = ZQSheet.createRow(rowNumber);
//                    }
//
//                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
//                    Cell cell = row.getCell(columnNumber);
//                    if (cell == null) {
//                        cell = row.createCell(columnNumber);
//                    }
//
//                    // 填充数据
//                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());
//
//                    // 增加已填充计数
//                    filledCounts[day][screwTypeId]++;
//                }
//            }
//
//            // 用于跟踪每天每种ScrewTypeId已填充的数量
//            int[][] filledCounts2 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
//            //处理左后门数据
//            for (SampleScrew sampleScrew : sampleScrews) {
//                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//// 查找日期和时间的分隔符（空格）的位置
//                int spaceIndex = createTime.indexOf(' ');
//// 查找日期部分中最后一个短横线的位置
//                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
//// 从最后一个短横线后开始截取，直到空格前，即为日部分
//                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
////            log.info("dayStr是"+dayStr);
//// 将日部分转换为整数
//                int day = Integer.parseInt(dayStr);
////            log.info("day是" + day);
//
//                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
//                if (screwTypeId <= 4 || screwTypeId >= 9) {
//                    continue;
//                }
//
//                // 计算行号和列号
//                int rowOffset = (screwTypeId - 5) * 21; // 每个screwTypeId占据27行
//                int rowNumber = 16 + rowOffset + filledCounts2[day][screwTypeId]; // 从第22行开始填充，加上偏移量
//
//                // 检查是否已经填充了8个数据
////            log.info("filledCounts[day][screwTypeId]是:"+filledCounts2[day][screwTypeId]);
//                if (filledCounts2[day][screwTypeId] < 8) {
//                    // 获取或创建行和单元格
//                    Row row = ZHSheet.getRow(rowNumber);
//                    if (row == null) {
//                        row = ZHSheet.createRow(rowNumber);
//                    }
//
//                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
//                    Cell cell = row.getCell(columnNumber);
//                    if (cell == null) {
//                        cell = row.createCell(columnNumber);
//                    }
//
//                    // 填充数据
//                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());
//
//                    // 增加已填充计数
//                    filledCounts2[day][screwTypeId]++;
//                }
//            }
//
//            // 用于跟踪每天每种ScrewTypeId已填充的数量
//            int[][] filledCounts3 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
//            //处理右前门数据
//            for (SampleScrew sampleScrew : sampleScrews) {
//
////            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
//                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
////            log.info("createTime是" + createTime);
//// 查找日期和时间的分隔符（空格）的位置
//                int spaceIndex = createTime.indexOf(' ');
//// 查找日期部分中最后一个短横线的位置
//                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
//// 从最后一个短横线后开始截取，直到空格前，即为日部分
//                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
////            log.info("dayStr是"+dayStr);
//// 将日部分转换为整数
//                int day = Integer.parseInt(dayStr);
////            log.info("day是" + day);
//
//                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
//                if (screwTypeId <= 8 || screwTypeId >= 13) {
//                    continue;
//                }
//
//                // 计算行号和列号
//                int rowOffset = (screwTypeId - 9) * 21; // 每个screwTypeId占据27行
//                int rowNumber = 16 + rowOffset + filledCounts3[day][screwTypeId]; // 从第22行开始填充，加上偏移量
//
//                // 检查是否已经填充了8个数据
////            log.info("filledCounts[day][screwTypeId]是:"+filledCounts3[day][screwTypeId]);
//                if (filledCounts3[day][screwTypeId] < 8) {
//                    // 获取或创建行和单元格
//                    Row row = YQSheet.getRow(rowNumber);
//                    if (row == null) {
//                        row = YQSheet.createRow(rowNumber);
//                    }
//
//                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
//                    Cell cell = row.getCell(columnNumber);
//                    if (cell == null) {
//                        cell = row.createCell(columnNumber);
//                    }
//
//                    // 填充数据
//                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());
//
//                    // 增加已填充计数
//                    filledCounts3[day][screwTypeId]++;
//                }
//            }
//
//            // 用于跟踪每天每种ScrewTypeId已填充的数量
//            int[][] filledCounts4 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
//            //处理右后门数据
//            for (SampleScrew sampleScrew : sampleScrews) {
//
//                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//// 查找日期和时间的分隔符（空格）的位置
//                int spaceIndex = createTime.indexOf(' ');
//// 查找日期部分中最后一个短横线的位置
//                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
//// 从最后一个短横线后开始截取，直到空格前，即为日部分
//                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
////            log.info("dayStr是"+dayStr);
//// 将日部分转换为整数
//                int day = Integer.parseInt(dayStr);
////            log.info("day是" + day);
//
//                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
//                if (screwTypeId <= 12 || screwTypeId >= 17) {
//                    continue;
//                }
//
//                // 计算行号和列号
//                int rowOffset = (screwTypeId - 13) * 21; // 每个screwTypeId占据27行
//                int rowNumber = 16 + rowOffset + filledCounts4[day][screwTypeId]; // 从第22行开始填充，加上偏移量
//
//                // 检查是否已经填充了8个数据
////                log.info("filledCounts[day][screwTypeId]是:" + filledCounts4[day][screwTypeId]);
//                if (filledCounts4[day][screwTypeId] < 8) {
//                    // 获取或创建行和单元格
//                    Row row = YHSheet.getRow(rowNumber);
////                    log.info("第几行" + rowNumber);
//                    if (row == null) {
//                        row = YHSheet.createRow(rowNumber);
//                    }
//
//                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
//                    Cell cell = row.getCell(columnNumber);
//                    if (cell == null) {
//                        cell = row.createCell(columnNumber);
//                    }
//
//                    // 填充数据
//                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());
//
//                    // 增加已填充计数
//                    filledCounts4[day][screwTypeId]++;
//                }
//            }
//
//            // 用于跟踪每天每种ScrewTypeId已填充的数量
//            int[][] filledCounts5 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
//            //处理车盖数据
//            for (SampleScrew sampleScrew : sampleScrews) {
//
////            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
//                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
////            log.info("createTime是" + createTime);
//// 查找日期和时间的分隔符（空格）的位置
//                int spaceIndex = createTime.indexOf(' ');
//// 查找日期部分中最后一个短横线的位置
//                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
//// 从最后一个短横线后开始截取，直到空格前，即为日部分
//                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
////            log.info("dayStr是"+dayStr);
//// 将日部分转换为整数
//                int day = Integer.parseInt(dayStr);
////            log.info("day是" + day);
//
//                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());
//
//                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
//                if (screwTypeId <= 16 || screwTypeId >= 21) {
//                    continue;
//                }
//
//                // 计算行号和列号
//                int rowOffset = (screwTypeId - 17) * 25; // 每个screwTypeId之间相隔25行
//                int rowNumber = 16 + rowOffset + filledCounts5[day][screwTypeId]; // 从第16行开始填充，加上偏移量
//
//                // 检查是否已经填充了8个数据
////                log.info("filledCounts[day][screwTypeId]是:" + filledCounts5[day][screwTypeId]);
//                if (filledCounts5[day][screwTypeId] < 8) {
//                    // 获取或创建行和单元格
//                    Row row = CGSheet.getRow(rowNumber);
////                    log.info("第几行" + rowNumber);
//                    if (row == null) {
//                        row = CGSheet.createRow(rowNumber);
//                    }
//
//                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
//                    Cell cell = row.getCell(columnNumber);
//                    if (cell == null) {
//                        cell = row.createCell(columnNumber);
//                    }
//
//                    // 填充数据
//                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());
//
//                    // 增加已填充计数
//                    filledCounts5[day][screwTypeId]++;
//                }
//            }
//        }else {
//            log.info("未知车型");
//            return null;
//        }
//        String fileName = null;
//        if(carType.equals(carTypeProperties.getCamry())){
//            fileName = "(" + month + ")" + MessageConstant.camryFileName; // 指定路径，同名就会会覆盖之前生成的文件
//        }else if(carType.equals(carTypeProperties.getLevin())){
//            fileName = "(" + month + ")" + MessageConstant.levinFileName;
//        }
//        Map map = new HashMap();
//        map.put("fileName", fileName);
//        map.put("excel", excel);
//        return map;
//    }

    //旧的写excel方法，取样8次
    private Map processCarType(String carType, String month) {
        LambdaQueryWrapper<SampleScrew> querySampleScrewWrapper = new LambdaQueryWrapper<>();
        querySampleScrewWrapper.like(SampleScrew::getScrewCreateTime, month);
        querySampleScrewWrapper.eq(SampleScrew::getCarType, carType);
        List<SampleScrew> sampleScrews = sampleScrewMapper.selectList(querySampleScrewWrapper);

        if (sampleScrews.isEmpty()) {
            System.out.println("没有找到前个月的" + carType + "车型");
//            return null;
        }

        //如果数据库里有凯美瑞的车型样本，就先把所有凯美瑞的车型查出来，然后每天每30台车取一粒螺丝扭力检测数据
        InputStream in = null;
        if(carType.equals(carTypeProperties.getCamry())) {
            in = this.getClass().getClassLoader()
                    .getResourceAsStream("template/"+ MessageConstant.camryFileName);
        }else if(carType.equals(carTypeProperties.getLevin())) {
            in = this.getClass().getClassLoader()
                    .getResourceAsStream("template/"+MessageConstant.levinFileName);
        }else {
            log.info("未知车型");
            return null;
        }
        //基于模板文件创建Excel文件
        //旧格式
        HSSFWorkbook excel = null;
        //新格式
//        XSSFWorkbook excel = null;
        try {
            POIFSFileSystem fs = new POIFSFileSystem(in);
            excel = new HSSFWorkbook(fs);
            //新格式
//            excel = new XSSFWorkbook(in);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        HSSFSheet YQSheet = excel.getSheet("右前门扭力");
        HSSFSheet ZQSheet = excel.getSheet("左前门扭力");
        HSSFSheet YHSheet = excel.getSheet("右后门扭力 (2)");
        HSSFSheet ZHSheet = excel.getSheet("左后门扭力");
        HSSFSheet CGSheet = excel.getSheet("发动机盖");

        if(carType.equals(carTypeProperties.getCamry())) {

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            //处理左前后门数据
            for (SampleScrew sampleScrew : sampleScrews) {

                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId >= 5) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 1) * 27; // 每个screwTypeId占据27行
                int rowNumber = 22 + rowOffset + filledCounts[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
                if (filledCounts[day][screwTypeId] < 8) {
                    // 获取或创建行和单元格
                    Row row = ZQSheet.getRow(rowNumber);
                    if (row == null) {
                        row = ZQSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts[day][screwTypeId]++;
                }

            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts2 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            //处理左后门数据
            for (SampleScrew sampleScrew : sampleScrews) {

//            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 4 || screwTypeId >= 9) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 5) * 27; // 每个screwTypeId占据27行
                int rowNumber = 22 + rowOffset + filledCounts2[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//            log.info("filledCounts[day][screwTypeId]是:"+filledCounts2[day][screwTypeId]);
                if (filledCounts2[day][screwTypeId] < 8) {
                    // 获取或创建行和单元格
                    Row row = ZHSheet.getRow(rowNumber);
//                log.info("第几行"+rowNumber);
                    if (row == null) {
                        row = ZHSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts2[day][screwTypeId]++;
                }
            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts3 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            //处理右前门数据
            for (SampleScrew sampleScrew : sampleScrews) {

//            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 8 || screwTypeId >= 13) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 9) * 27; // 每个screwTypeId占据27行
                int rowNumber = 22 + rowOffset + filledCounts3[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//            log.info("filledCounts[day][screwTypeId]是:"+filledCounts3[day][screwTypeId]);
                if (filledCounts3[day][screwTypeId] < 8) {
                    // 获取或创建行和单元格
                    Row row = YQSheet.getRow(rowNumber);
//                log.info("第几行"+rowNumber);
                    if (row == null) {
                        row = YQSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts3[day][screwTypeId]++;
                }
            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts4 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            //处理右后门数据
            for (SampleScrew sampleScrew : sampleScrews) {

//            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 12 || screwTypeId >= 17) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 13) * 27; // 每个screwTypeId占据27行
                int rowNumber = 22 + rowOffset + filledCounts4[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//                log.info("filledCounts[day][screwTypeId]是:" + filledCounts4[day][screwTypeId]);
                if (filledCounts4[day][screwTypeId] < 8) {
                    // 获取或创建行和单元格
                    Row row = YHSheet.getRow(rowNumber);
//                    log.info("第几行" + rowNumber);
                    if (row == null) {
                        row = YHSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts4[day][screwTypeId]++;
                }
            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts5 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            //处理车盖数据
            for (SampleScrew sampleScrew : sampleScrews) {

//            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 16 || screwTypeId >= 21) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 17) * 25; // 每个screwTypeId之间相隔25行
                int rowNumber = 16 + rowOffset + filledCounts5[day][screwTypeId]; // 从第16行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//                log.info("filledCounts[day][screwTypeId]是:" + filledCounts5[day][screwTypeId]);
                if (filledCounts5[day][screwTypeId] < 8) {
                    // 获取或创建行和单元格
                    Row row = CGSheet.getRow(rowNumber);
//                    log.info("第几行" + rowNumber);
                    if (row == null) {
                        row = CGSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts5[day][screwTypeId]++;
                }
            }
        }
        else if(carType.equals(carTypeProperties.getLevin())) {
            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            //处理左前后门数据
            for (SampleScrew sampleScrew : sampleScrews) {

                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId >= 5) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 1) * 21; // 每个screwTypeId占据27行
                int rowNumber = 16 + rowOffset + filledCounts[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
                if (filledCounts[day][screwTypeId] < 8) {
                    // 获取或创建行和单元格
                    Row row = ZQSheet.getRow(rowNumber);
                    if (row == null) {
                        row = ZQSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts[day][screwTypeId]++;
                }
            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts2 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            //处理左后门数据
            for (SampleScrew sampleScrew : sampleScrews) {
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 4 || screwTypeId >= 9) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 5) * 21; // 每个screwTypeId占据27行
                int rowNumber = 16 + rowOffset + filledCounts2[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//            log.info("filledCounts[day][screwTypeId]是:"+filledCounts2[day][screwTypeId]);
                if (filledCounts2[day][screwTypeId] < 8) {
                    // 获取或创建行和单元格
                    Row row = ZHSheet.getRow(rowNumber);
                    if (row == null) {
                        row = ZHSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts2[day][screwTypeId]++;
                }
            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts3 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            //处理右前门数据
            for (SampleScrew sampleScrew : sampleScrews) {

//            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 8 || screwTypeId >= 13) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 9) * 21; // 每个screwTypeId占据27行
                int rowNumber = 16 + rowOffset + filledCounts3[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//            log.info("filledCounts[day][screwTypeId]是:"+filledCounts3[day][screwTypeId]);
                if (filledCounts3[day][screwTypeId] < 8) {
                    // 获取或创建行和单元格
                    Row row = YQSheet.getRow(rowNumber);
                    if (row == null) {
                        row = YQSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts3[day][screwTypeId]++;
                }
            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts4 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            //处理右后门数据
            for (SampleScrew sampleScrew : sampleScrews) {

                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 12 || screwTypeId >= 17) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 13) * 21; // 每个screwTypeId占据27行
                int rowNumber = 16 + rowOffset + filledCounts4[day][screwTypeId]; // 从第22行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//                log.info("filledCounts[day][screwTypeId]是:" + filledCounts4[day][screwTypeId]);
                if (filledCounts4[day][screwTypeId] < 8) {
                    // 获取或创建行和单元格
                    Row row = YHSheet.getRow(rowNumber);
//                    log.info("第几行" + rowNumber);
                    if (row == null) {
                        row = YHSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts4[day][screwTypeId]++;
                }
            }

            // 用于跟踪每天每种ScrewTypeId已填充的数量
            int[][] filledCounts5 = new int[32][21]; // 假设一个月最多31天，ScrewTypeId从1到20
            //处理车盖数据
            for (SampleScrew sampleScrew : sampleScrews) {

//            log.info("filledCounts1是"+ Arrays.deepToString(filledCounts));
                String createTime = convertLocalDateTimeToString(sampleScrew.getScrewCreateTime());
//            log.info("createTime是" + createTime);
// 查找日期和时间的分隔符（空格）的位置
                int spaceIndex = createTime.indexOf(' ');
// 查找日期部分中最后一个短横线的位置
                int lastDashIndex = createTime.lastIndexOf('-', spaceIndex);
// 从最后一个短横线后开始截取，直到空格前，即为日部分
                String dayStr = createTime.substring(lastDashIndex + 1, spaceIndex);
//            log.info("dayStr是"+dayStr);
// 将日部分转换为整数
                int day = Integer.parseInt(dayStr);
//            log.info("day是" + day);

                int screwTypeId = Math.toIntExact(sampleScrew.getScrewTypeId());

                // 如果screwTypeId为5及以上，则跳过，因为这些数据应该填充到其他sheet页
                if (screwTypeId <= 16 || screwTypeId >= 21) {
                    continue;
                }

                // 计算行号和列号
                int rowOffset = (screwTypeId - 17) * 25; // 每个screwTypeId之间相隔25行
                int rowNumber = 16 + rowOffset + filledCounts5[day][screwTypeId]; // 从第16行开始填充，加上偏移量

                // 检查是否已经填充了8个数据
//                log.info("filledCounts[day][screwTypeId]是:" + filledCounts5[day][screwTypeId]);
                if (filledCounts5[day][screwTypeId] < 8) {
                    // 获取或创建行和单元格
                    Row row = CGSheet.getRow(rowNumber);
//                    log.info("第几行" + rowNumber);
                    if (row == null) {
                        row = CGSheet.createRow(rowNumber);
                    }

                    int columnNumber = 3 + day; // 从第4列开始填充，对应第一天
                    Cell cell = row.getCell(columnNumber);
                    if (cell == null) {
                        cell = row.createCell(columnNumber);
                    }

                    // 填充数据
                    cell.setCellValue(sampleScrew.getTorque() + "\n" + sampleScrew.getUnit());

                    // 增加已填充计数
                    filledCounts5[day][screwTypeId]++;
                }
            }
        }else {
            log.info("未知车型");
            return null;
        }


//        String Path = basePath + "\\";
        // 确保目录存在，如果不存在则创建
//        createDirectoryIfNotExists(Path);
        String fileName = null;
        if(carType.equals(carTypeProperties.getCamry())){
            fileName = "(" + month + ")" + MessageConstant.camryFileName; // 指定路径，同名就会会覆盖之前生成的文件
        }else if(carType.equals(carTypeProperties.getLevin())){
            fileName = "(" + month + ")" + MessageConstant.levinFileName;
        }

//        try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
//            excel.write(fileOutputStream); // 写入数据
//            log.info(carType + "车型的抽样Excel文件已成功导出到: " + filePath);
            Map map = new HashMap();
            map.put("fileName", fileName);
            map.put("excel", excel);
            return map;
//        } catch (IOException e) {
//            log.info("导出" + carType + "车型的Excel文件时出错: " + e.getMessage());
//        } finally {
//            try {
//                excel.close(); // 关闭工作簿
//            } catch (IOException e) {
//                log.info("关闭" + carType + "车型的工作簿时出错: " + e.getMessage());
//            }
//        }
//        return null;
    }
}
